shared source/vb/language/shared/norlsallocator.h

   1 //-------------------------------------------------------------------------------------------------
   2 //
   3 //  Copyright (c) Microsoft Corporation.  All rights reserved.
   4 //
   5 //  Implements No Release Allocator.
   6 //
   7 //-------------------------------------------------------------------------------------------------
   8
   9 #pragma once
  10
  11
  12 //to track nrlsalloc locations, #define NRLSTRACK
  13 // set NRLSTRACK_GETSTACKS to 1 to track NRLSAllocations and the call stacks. Uses lots of mem: very expensive
  14
  15 //#define NRLSTRACK  DEBUG &&  !defined( VBDBGEE )  && !defined(NDEBUG) && !defined(BUILDING_VBC) && !defined(BUILDING_VB7TO8)
  16 //#define NRLSTRACK_GETSTACKS NRLSTRACK
  17
  18 #if NRLSTRACK
  19
  20 // we're tracking allocations.
  21
  22 #include <hash_set>
  23 using namespace stdext;
  24
  25 // we're tracking allocations.
  26
  27 struct VBMemoryInUse
  28 {
  29     long nHeapTotalBytes;
  30     long nHeapTotalAllocs;
  31
  32     long nNrlsTotalBytes;
  33     long nNrlsTotalAllocs;
  34
  35 };
  36
  37 class NrlsAllocTracker
  38 {
  39 public:
  40     NrlsAllocTracker():
  41         g_nSerialNo(0)
  42     {
  43     }
  44     ~NrlsAllocTracker()
  45     {
  46     }
  47     long AddAllocator(NorlsAllocator *pAllocator);
  48
  49     void RemoveAllocator(NorlsAllocator *pAllocator);
  50
  51     CComBSTR GetAllocatorStatusReport(_Out_ long *pnCnt, _Out_ long *pnTotMem);
  52     VBMemoryInUse & GetVBMemoryStats(_In_ LPCSTR strDesc);
  53
  54
  55 private:
  56     typedef std::list<NorlsAllocator *> listNorls;
  57     listNorls m_set;
  58     CTinyLock m_lock;
  59     long g_nSerialNo;
  60     VBMemoryInUse m_VBMemoryInUse ;
  61 };
  62
  63
  64 extern NrlsAllocTracker *g_NrlsAllocTracker;
  65 #if NRLSTRACK_GETSTACKS
  66     typedef struct {
  67         void * m_ptrNextBlock; // linked list of allocations: point to prior one
  68         size_t m_size; // size of the nrls data
  69         void * m_data; // ptr to the actual NRLS data
  70     } NrlsHeapData;
  71 #endif NRLSTRACK_GETSTACKS
  72
  73 #endif NRLSTRACK
  74
  75
  76
  77 // Holds a page of memory being used by the NorlsAllocator.
  78 struct NorlsPage
  79 {
  80 #if DEBUG
  81     size_t sentinalStart;
  82 #endif
  83
  84     NorlsPage * next;      // next page in use.
  85     BYTE * firstAvail;  // first available byte for allocation.
  86     BYTE * limitAvail;  // limit for allocation.
  87
  88 #if DEBUG
  89     size_t sentinalEnd; // Buffer overflow check
  90 #endif
  91 };
  92
  93 class NorlsMark
  94 {
  95 private:
  96     friend class NorlsAllocator;
  97
  98     NorlsPage * page;      // page.
  99     BYTE * nextFree;    // first free location within the page.
 100     unsigned depth;
 101
 102 #if NRLSTRACK
 103     long m_nTotalAllocatedAtMark;
 104 #if NRLSTRACK_GETSTACKS
 105     NrlsHeapData * m_pLastBlockAtMark;           // ptr to linked list of alloc'd Heap blocks so VSAssert CHeapSpy can watch Nrlsallocs
 106 #endif NRLSTRACK_GETSTACKS
 107 #endif //NRLSTRACK
 108
 109 };
 110
 111
 112 #if NRLSTRACK
 113 #define NORLSLOC __WFILE__, __LINE__
 114 #else
 115 #define NORLSLOC -1
 116 #endif
 117
 118 class NorlsAllocator
 119 {
 120 friend class NrlsAllocTracker;
 121 public:
 122     NEW_CTOR_SAFE()
 123
 124     class AllowingWrite
 125     {
 126     private:
 127         NorlsAllocator * heap;
 128         bool alreadyInAllowingWrite;
 129     public:
 130         AllowingWrite(NorlsAllocator * heap)
 131         {
 132             this->heap = heap;
 133             if (heap)
 134             {
 135                 alreadyInAllowingWrite = heap->inAllowingWrite;
 136                 heap->inAllowingWrite = true;
 137             }
 138             else
 139             {
 140                 alreadyInAllowingWrite = false;
 141             }
 142         }
 143         ~AllowingWrite()
 144         {
 145             if (!alreadyInAllowingWrite && heap)
 146             {
 147                 heap->inAllowingWrite = false;
 148             }
 149         }
 150         bool OwnsHeapWriteability()
 151         {
 152             return !alreadyInAllowingWrite;
 153         }
 154     };
 155
 156
 157
 158     NorlsAllocator(
 159 #if NRLSTRACK
 160      _In_ WCHAR *szFile, _In_ long nLineNo
 161 #else
 162     _In_ int nUnused
 163 #endif NRLSTRACK
 164     );
 165     ~NorlsAllocator();
 166
 167     NorlsAllocator(
 168 #if NRLSTRACK
 169      _In_ WCHAR *szFile, _In_ long nLineNo,
 170 #else
 171     _In_ int nUnused,
 172 #endif NRLSTRACK
 173     _In_ PageHeap& heapToAllocateFrom
 174     );
 175
 176     PageHeap& GetPageHeap()
 177     {
 178         return m_heapPage;
 179     }
 180
 181     void ForbidWrite(void * p, size_t sz)
 182     {
 183         VerifyHeapEntity();
 184         ForbidWriteInternal(p, sz);
 185     }
 186     void AllowWrite(void * p, size_t sz)
 187     {
 188         VerifyHeapEntity();
 189         AllowWriteInternal(p, sz);
 190     }
 191
 192     void DisallowReadOnlyDirectives()
 193     {
 194         VerifyHeapEntity();
 195         DisallowReadOnlyDirectivesInternal();
 196     }
 197     void AllowReadOnlyDirectives()
 198     {
 199         VerifyHeapEntity();
 200         AllowReadOnlyDirectivesInternal();
 201     }
 202     bool AllowingReadOnlyDirectives()
 203     {
 204         VerifyHeapEntity();
 205         return AllowingReadOnlyDirectivesInternal();
 206     }
 207     void MakeCurrentPageReadOnly()
 208     {
 209         VerifyHeapEntity();
 210         MakeCurrentPageReadOnlyInternal();
 211     } // Calling Alloc makes it writeable until the next call to MakeReadOnly
 212     void MakeCurrentPageWriteable()
 213     {
 214         VerifyHeapEntity();
 215         MakeCurrentPageWriteableInternal();
 216     } // Calling Alloc makes it writeable until the next call to MakeReadOnly
 217     void MakeAllHeapReadOnly()
 218     {
 219         VerifyHeapEntity();
 220         MakeAllHeapReadOnlyInternal();
 221     }
 222     void MakeAllHeapWriteable()
 223     {
 224         VerifyHeapEntity();
 225         MakeAllHeapWriteableInternal();
 226     }
 227
 228     bool IsAddressInCurrentPage (const void * addr) const;
 229     bool IsAddressInHeap (const void * addr) const
 230     {
 231         for (NorlsPage * page = pageList; page; page = page->next)
 232         {
 233             if (addr >= page && addr < page->limitAvail)
 234                 return true;
 235         }
 236         return false;
 237     }
 238
 239     void* AllocNonZero(size_t sz);
 240     void* Alloc(size_t sz);
 241     template <typename T>
 242     T* Alloc()
 243     {
 244         return (T*)Alloc(sizeof(T));
 245     }
 246     template <typename T>
 247     T* _fastcall AllocArray(size_t count)
 248     {
 249         return (T*)Alloc(VBMath::Multiply(sizeof(T),count));
 250     }
 251
 252     void *Resize(
 253         _In_bytecount_(cbSizeOld) void* pv,
 254         _In_ size_t cbSizeOld,
 255         _In_ size_t cbSizeNew);
 256
 257     void ValidateHeap();
 258     PWSTR AllocStr(PCWSTR str);
 259     NorlsMark Mark();
 260     void Mark(NorlsMark * mark);
 261     void Free(NorlsMark * mark);
 262     void FreeHeap();
 263     size_t CalcCommittedSize () const;
 264     const WCHAR* GetDebugIdentifier() const;
 265 #if NRLSTRACK
 266     WCHAR *m_szFile;
 267     long m_nLineNo;
 268     DWORD m_dwCreatedThreadId; // the thread on which this allocator was created
 269     DWORD m_dwAllocThreadId;// the thread on which allocations are occuring
 270     long m_nSerialNo;        // the allocator's serialno
 271     long m_nSeqNo;  /// the sequence # of the allocation for this allcoator
 272     ULONG m_nTotalAllocated;
 273 #if NRLSTRACK_GETSTACKS
 274     NrlsHeapData  * m_pLastBlock;           // ptr to linked list of alloc'd Heap blocks so VSAssert CHeapSpy can watch Nrlsallocs
 275     HANDLE  TrackingHeapToUse();
 276     static HANDLE g_nraSymbolHeap ;
 277
 278 #endif NRLSTRACK_GETSTACKS
 279
 280
 281 #endif NRLSTRACK
 282
 283 private:
 284     NorlsAllocator(const NorlsAllocator&);
 285     NorlsAllocator& operator=(const NorlsAllocator&);
 286
 287     void Init(ProtectedEntityFlagsEnum entity);
 288     void VerifyHeapEntity()
 289     {
 290         VSASSERT(entity, "Heap entity must be set before manipulating heap writeability");
 291     }
 292     void VerifyHeap();
 293     void ForbidWriteInternal(void * p, size_t sz);
 294     void AllowWriteInternal(void * p, size_t sz);
 295
 296     //allocates memory but doesn't clear it.
 297     //'sz' [in/out] returns the true allocation size
 298     void* _AllocNonZero(size_t& sz);
 299
 300     void DisallowReadOnlyDirectivesInternal()
 301     {
 302         allowReadOnlyDirectives = false;
 303     }
 304     void AllowReadOnlyDirectivesInternal()
 305     {
 306         allowReadOnlyDirectives = true;
 307     }
 308     bool AllowingReadOnlyDirectivesInternal()
 309     {
 310         return allowReadOnlyDirectives;
 311     }
 312     void MakeCurrentPageReadOnlyInternal(); // Calling Alloc makes it writeable until the next call to MakeReadOnly
 313     void MakeCurrentPageWriteableInternal(); // Calling Alloc makes it writeable until the next call to MakeReadOnly
 314     void MakeAllHeapReadOnlyInternal();
 315     void MakeAllHeapWriteableInternal();
 316
 317     void SetPageWriteStatus(NorlsPage * page, bool writeable);
 318     void SetPageRegionWriteStatus(NorlsPage * first, NorlsPage * last, bool writeable);
 319     void SetAllPagesWriteStatus(bool writeable);
 320
 321     BYTE * nextFree;                // location of free area
 322     BYTE * limitFree;               // just beyond end of free area in this page.
 323
 324     NorlsPage * pageList;              // list of pages used by this allocator.
 325     NorlsPage * pageLast;              // last page in the list.
 326
 327     // The source of pages for this heap.
 328     PageHeap& m_heapPage;
 329     unsigned m_depth;
 330
 331     void AllocNewPage(size_t sz);
 332     NorlsPage * NewPage(size_t sz);
 333
 334     ProtectedEntityFlagsEnum entity;
 335     bool allowReadOnlyDirectives;
 336     bool anyPageMarkedReadOnly;
 337     bool inAllowingWrite;
 338
 339 #ifdef DEBUG
 340     inline size_t DebugSize (size_t sz) const
 341     {
 342         // integer overflow
 343         if (!(sz < sz + 1 + sizeof(size_t) + sizeof(void*) + sizeof(void*)))
 344         {
 345             VSASSERT(sz < sz + 1 + sizeof(size_t) + sizeof(void*) + sizeof(void*), "Invalid");
 346             return 0;
 347         }
 348         return VBMath::RoundUpAllocSize(sizeof(size_t)) + VBMath::RoundUpAllocSize(sz + 1); // int at beginning for size, plus 1 (or more) bytes of sentinel.
 349     }
 350     static const BYTE DEBUGSENTINAL = 0xAE;  // put at end of block to detect overrun.
 351 #endif //DEBUG
 352 };
 353
 354 class NRHeapMarker
 355 {
 356 public:
 357     NRHeapMarker(NorlsAllocator * h)
 358     {
 359         heap = h;
 360         heap->Mark(&mark);
 361     }
 362     ~NRHeapMarker()
 363     {
 364         heap->Free(&mark);
 365     }
 366 private:
 367     NorlsAllocator * heap;
 368     NorlsMark mark;
 369 };
 370
 371 class NRHeapWriteMaker
 372 {
 373 public:
 374     NRHeapWriteMaker(NorlsAllocator * heap) : allowingWrite(heap)
 375     {
 376         this->heap = heap;
 377         if (heap)
 378         {
 379             heap->MakeAllHeapWriteable();
 380         }
 381     }
 382     ~NRHeapWriteMaker()
 383     {
 384         if (heap && allowingWrite.OwnsHeapWriteability())
 385         {
 386             heap->AllowReadOnlyDirectives();
 387             heap->MakeAllHeapReadOnly();
 388         }
 389     }
 390 private:
 391     NorlsAllocator * heap;
 392     NorlsAllocator::AllowingWrite allowingWrite;
 393 };
 394
 395 class NRHeapWriteAllower
 396 {
 397 public:
 398     NRHeapWriteAllower(NorlsAllocator * heap) : allowingWrite(heap)
 399     {
 400         this->heap = heap;
 401         if (heap)
 402         {
 403             heap->DisallowReadOnlyDirectives();
 404         }
 405     }
 406     ~NRHeapWriteAllower()
 407     {
 408         if (heap && allowingWrite.OwnsHeapWriteability())
 409         {
 410             heap->AllowReadOnlyDirectives();
 411             heap->MakeAllHeapReadOnly();
 412         }
 413     }
 414 private:
 415     NorlsAllocator * heap;
 416     NorlsAllocator::AllowingWrite allowingWrite;
 417 };
 418